home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / optivc32 / newcplx.h < prev    next >
C/C++ Source or Header  |  1999-03-06  |  63KB  |  1,286 lines
  1. /* newcmplx.h
  2.  
  3.     Include-File for the CMATH Complex Number Library
  4.     replaces <complex.h>.
  5.  
  6.     Copyright (C) 1996-1999 Martin Sander
  7.     Address of the author:
  8.            Dr. Martin Sander Software Dev.
  9.            Sertuernerstr. 11
  10.            D-37085 Goettingen
  11.            Germany
  12.            MartinSander@Bigfoot.com
  13.            http://www.optivec.com
  14.  
  15.     for C++, the following classes are defined:
  16.     a) if you choose the "classic" Borland C++ style:  class complex;
  17.     b) otherwise:
  18.        classes complex<float>, complex<double>, and complex<long double>.
  19.     fComplex, dComplex, and eComplex are defined as synonyms for these classes.
  20.  
  21.     Fo plain C, use <cmath.h> instead, which declares fComplex, dComplex,
  22.     and eComplex as structs, along with the same range of functions as
  23.     present in the complex C++ classes.
  24.  
  25.     The classes complex and complex<double> are binary compatible with
  26.     the C struct dComplex. Similarly, complex<float> and struct fComplex
  27.     as well as class complex<long double> and struct eComplex are mutually
  28.     compatible. This is important if one has programs with some modules
  29.     written in C, others in C++.
  30.  
  31.     All mathematical complex functions are implemented as a library
  32.     written in Assembler language. In comparison to C++ inline functions,
  33.     this leads to greater precision, greater speed and best security due
  34.     to complete error handling via the standard C error handling functions
  35.     _matherr() (for complex<float> and complex<double>)
  36.     and _matherrl() (for complex<long double>).
  37.  
  38.     The declarations for the Standard Library complex classes have
  39.     partly been adapted from the implementation by Rogue Wave Software, Inc.
  40.     The function bodies, however, are completely new.
  41.  
  42.     Note the following important differences between this implementation
  43.     and the one contained in <complex.h>:
  44.     -  The real and imaginary parts are declared as public and are referred
  45.        to as  Re and Im, so that you may always access them as z.Re and z.Im
  46.        in addition to the member functions real(z) and imag(z);
  47.     -  The argument of all mathematical functions is a value, not a reference.
  48.     -  The following functions and operators have been added:
  49.        friend complex  cubic(complex);  //   third power
  50.        friend complex  inv(complex);    //   1.0 / z
  51.        friend complex  ipow(complex __base, int __expo);  // integer power
  52.        friend complex  log2(complex);
  53.        friend complex  powReExpo(complex __base, double __expoRe);
  54.                                        // explicit power with real exponent
  55.        friend complex  powReBase(double __baseRe, complex __expo);
  56.                                        // explicit power of real base
  57.        friend complex  quartic(complex);  // fourth power
  58.        friend complex  square(complex);
  59.        friend int      operator==(complex &, double);
  60.        friend int      operator!=(complex &, double);
  61.        Also new are many of the mixed-accuracy level binary operators.
  62. */
  63.  
  64. #ifndef __cplusplus
  65. #error Must use C++ for complex classes. Include <cmath.h> for the plain-C version
  66. #endif
  67. #if !defined(__NEWCPLX_H)
  68. #define __NEWCPLX_H
  69.  
  70.  
  71.       /* define _VFAR to get around the buggy definition of _FAR : */
  72. #if defined __TINY || defined __SMALL__ || defined __MEDIUM__
  73.     #if defined(_RTLDLL) || defined(_CLASSDLL)
  74.         #error Must use static BC Runtime Library with OptiVec in models TINY, SMALL, MEDIUM
  75.     #endif
  76.     #define   _VFAR  near   /* even in case of DS!=SS  */
  77. #elif defined __FLAT__ || defined _WIN32
  78.     #define  _VFAR
  79. #else
  80.     #define   _VFAR  far
  81. #endif
  82. #ifdef __BORLANDC__
  83.      #pragma option -a-
  84.      #if (__BORLANDC__ >= 0x450)
  85.          #define __cmf _RTLENTRY _EXPFUNC
  86.          #define __cmo _RTLENTRY
  87.     #else
  88.          #define __cmf  _Cdecl _FARFUNC
  89.          #define __cmo  _Cdecl
  90.     #endif
  91.     #if __BORLANDC__ < 0x500
  92.         #define VBOOL int
  93.     #else
  94.         #define VBOOL bool
  95.     #endif
  96. #else /* Visual C++, Watcom */
  97.      #pragma pack( push,1 )
  98.      #define VBOOL int
  99.      #define __cmf _cdecl
  100.      #define __cmo _cdecl
  101. #endif /* avoid insertion of dummy bytes  */
  102. #define _VFARC const _VFAR
  103.  
  104. #if !defined(__IOSTREAM_H)
  105. #include <iostream.h>
  106. #endif
  107.  
  108. #if defined( CMATH_CLASSIC_COMPLEX )
  109.       // classic Borland C++ class complex only. This has double precision.
  110.       // complex numbers of float and of long double precision are
  111.       // implemented as structs. So there is no constructor! Moreover, there
  112.       // are no functions defined for the float and long double complex numbers.
  113. #if !defined(__IOSTREAM_H)
  114. #include <iostream.h>
  115. #endif
  116.  
  117. #if !defined(RC_INVOKED)
  118.  
  119. #if defined(__BCOPT__)
  120. #if !defined(__FLAT__) && ((__BORLANDC__ < 0x450) || !defined(_RTL_ALLOW_po))
  121. #pragma option -po-     // disable Object data calling convention
  122. #endif
  123. #endif
  124.  
  125. #pragma option -Vo-
  126.  
  127. #if defined(__STDC__)
  128. #pragma warn -nak
  129. #endif
  130.  
  131. #endif  /* !RC_INVOKED */
  132.  
  133. #if(__BORLANDC__ >= 0x450)
  134. class _EXPCLASS complex {
  135. #else
  136. _CLASSDEF(complex)
  137. class _CLASSTYPE complex {
  138. #endif
  139.   public:
  140.     // constructors
  141.     complex( double Re_part, double Im_part ) {Re=Re_part; Im=Im_part;}
  142.     complex( double Re_part )  {Re=Re_part; Im=0;}
  143.     complex() {}; // more efficient to have these three separate variants
  144.     // Cartesian complex from polar coordinates:
  145.     friend complex __cmf polar(double _mag, double _angle=0);
  146.     // basic operations:
  147.     double real() { return Re; }                     // real part
  148.     double real(complex _VFARC &_z) { return _z.Re; }
  149.     double imag() { return Im; }                     // imaginary part
  150.     double imag(complex _VFARC &_z) { return _z.Im; } // imaginary part
  151.     friend complex __cmf neg(complex _VFARC &);   // same as unary operator -
  152.     friend complex __cmf conj(complex _VFARC &);  // complex conjugate
  153.     friend double  __cmf norm(complex);          // square of the magnitude
  154.     friend double  __cmf arg(complex);           // angle in the plane
  155.  
  156.      // Unary operators
  157.     complex _VFAR & __cmo operator+();
  158.     friend complex _VFAR & __cmf operator-( complex _VFARC &);
  159.  
  160.     // Binary operators
  161.     friend complex __cmf operator+(complex _VFARC &, complex _VFARC &);
  162.     friend complex __cmf operator+(double, complex _VFARC &);
  163.     friend complex __cmf operator+(complex _VFARC &, double);
  164.     friend complex __cmf operator-(complex _VFARC &, complex _VFARC &);
  165.     friend complex __cmf operator-(double, complex _VFARC &);
  166.     friend complex __cmf operator-(complex _VFARC &, double);
  167.     friend complex __cmf operator*(complex _VFARC &, complex _VFARC &);
  168.     friend complex __cmf operator*(complex _VFARC &, double);
  169.     friend complex __cmf operator*(double, complex _VFARC &);
  170.     friend complex __cmf operator/(complex _VFARC &, complex _VFARC &);
  171.     friend complex __cmf operator/(complex _VFARC &, double);
  172.     friend complex __cmf operator/(double, complex _VFARC &);
  173.  
  174.     friend VBOOL __cmf operator==(complex _VFARC &, complex _VFARC &);
  175.     friend VBOOL __cmf operator==(complex _VFARC &, double);
  176.     friend VBOOL __cmf operator!=(complex _VFARC &, complex _VFARC &);
  177.     friend VBOOL __cmf operator!=(complex _VFARC &, double);
  178.  
  179.     complex _VFAR & __cmo operator+=(complex _VFARC &);
  180.     complex _VFAR & __cmo operator+=(double);
  181.     complex _VFAR & __cmo operator-=(complex _VFARC &);
  182.     complex _VFAR & __cmo operator-=(double);
  183.     complex _VFAR & __cmo operator*=(complex _VFARC &);
  184.     complex _VFAR & __cmo operator*=(double);
  185.     complex _VFAR & __cmo operator/=(complex _VFARC &);
  186.     complex _VFAR & __cmo operator/=(double);
  187.  
  188.     // Overloaded ANSI C math functions with error handling via matherr():
  189.     friend double  __cmf abs(complex);    // complex pointer magnitude
  190.     friend complex __cmf acos(complex);
  191.     friend complex __cmf asin(complex);
  192.     friend complex __cmf atan(complex);
  193.     friend complex __cmf cos(complex);
  194.     friend complex __cmf cosh(complex);
  195.     friend complex __cmf cubic(complex);  // raise to the third power
  196.     friend complex _